// 抑制特定警告
process.env.NODE_OPTIONS = '--no-warnings';

import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import axios from 'axios';
import { GoogleGenerativeAI } from '@google/generative-ai';
import OpenAI from 'openai';
import Anthropic from "@anthropic-ai/sdk";
import https from 'https';
import { HttpsProxyAgent } from 'https-proxy-agent';
import fetch from 'node-fetch';
import path from 'path';
import { fileURLToPath } from 'url';
// import WebSocket from 'ws';
// import crypto from 'crypto';
// import punycode from 'punycode/';
// 导入百度文心一言服务
import ernieService from './anotherApiServer/ernieServer.js';
// 导入通义千问服务
import qwenService from './anotherApiServer/qwenApiServer.js';

// 获取 __dirname
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Load environment variables from both root and backend directory
dotenv.config({ path: '../client/.env' });
dotenv.config({ path: './.env' });

// 初始化 https agent
const httpsAgent = new https.Agent({
    rejectUnauthorized: false // 允许自签名证书
});

// 配置 axios 实例
const axiosInstance = axios.create({
    timeout: 60000,  // 增加超时时间到30秒
    httpsAgent: new https.Agent({
        rejectUnauthorized: false, // 允许自签名证书
        keepAlive: true,  // 启用 keepAlive
        timeout: 60000    // agent 超时时间
    }),
    maxRedirects: 5,     // 允许最多5次重定向
    validateStatus: function (status) {
        console.log('响应状态码:', status);
        return true;  // 允许所有状态码，不自动抛出错误
    },
    headers: {
        'User-Agent': 'Apifox/1.0.0 (https://apifox.com)',
        'Accept': '*/*',
        'Connection': 'keep-alive'
    }
});

// 添加请求拦截器
axiosInstance.interceptors.request.use(function (config) {
    console.log('\n=== 发送请求 ===');
    console.log('请求URL:', config.url);
    console.log('请求方法:', config.method);
    console.log('请求头:', config.headers);
    return config;
}, function (error) {
    console.error('请求错误:', error);
    return Promise.reject(error);
});

// 添加响应拦截器
axiosInstance.interceptors.response.use(function (response) {
    console.log('\n=== 收到响应 ===');
    console.log('响应状态:', response.status);
    return response;
}, function (error) {
    console.error('响应错误:', error);
    return Promise.reject(error);
});

if (process.env.HTTP_PROXY || process.env.HTTPS_PROXY) {
    console.log('使用代理配置:', process.env.HTTP_PROXY || process.env.HTTPS_PROXY);
    axiosInstance.defaults.proxy = true; // 使用 httpsAgent 处理代理
}

// 创建代理实例
const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
const proxyAgent = proxyUrl ? new HttpsProxyAgent(proxyUrl) : null;

// 配置全局 fetch
global.fetch = async (url, options = {}) => {
    console.log('请求详情 START ==================');
    console.log('请求URL:', url);
    console.log('代理URL:', proxyUrl || '未使用代理');
    console.log('请求选项:', JSON.stringify(options, null, 2));

    try {
        // 如果有代理，添加代理配置
        if (proxyAgent) {
            options.agent = proxyAgent;
            console.log('使用代理配置:', {
                agent: proxyUrl
            });
        }

        // 添加超时和其他默认配置
        options = {
            ...options,
            timeout: 10000,  // 10秒超时
            headers: {
                ...options.headers,
                'User-Agent': 'NodeJS Gemini Client'
            }
        };

        console.log('最终请求选项:', JSON.stringify(options, null, 2));

        const response = await fetch(url, options);

        console.log('响应状态码:', response.status);
        console.log('响应头:', JSON.stringify(response.headers, null, 2));

        // 尝试读取响应体
        const responseText = await response.text();
        console.log('响应体:', responseText);

        console.log('请求详情 END ==================');

        // 重新创建响应对象，因为 text() 方法只能读取一次
        return new Response(responseText, {
            status: response.status,
            headers: response.headers
        });
    } catch (error) {
        console.error('请求详情 ERROR ==================');
        console.error('错误类型:', error.constructor.name);
        console.error('错误信息:', error.message);
        console.error('错误码:', error.code);
        console.error('系统调用:', error.syscall);
        console.error('完整错误:', error);
        console.error('请求详情 ERROR END ==================');

        throw error;
    }
};

// 创建 Express 应用
const app = express();

// 使用JSON中间件
app.use(express.json());

// 定义允许的域名列表
const allowedOrigins = [
    'http://localhost',
    'http://localhost:5173',
    'http://localhost:8000',
    'http://localhost:81',
    'http://120.78.129.205',
    'http://127.0.0.1',
    'http://127.0.0.1:5173',
    'http://127.0.0.1:8000',
    'http://120.78.129.205:5173',
    'http://120.78.129.205:8000',
    'http://7gipcsl7p9.tcp01.cn',
    'http://ai.xuxiaowen.space',
    'http://wicpower-ai.xuxiaowen.space'
];

// 配置 CORS
app.use(cors({
    origin: function (origin, callback) {
        // 允许没有origin的请求（比如移动端APP）
        if (!origin) return callback(null, true);

        if (allowedOrigins.indexOf(origin) !== -1) {
            callback(null, true);
        } else {
            console.log('Blocked origin:', origin);
            callback(new Error('Not allowed by CORS'));
        }
    },
    credentials: true,
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH'],
    allowedHeaders: [
        'Content-Type',
        'X-API-Secret',
        'Authorization',
        'Accept',
        'User-Agent',
        'DNT',
        'Cache-Control',
        'X-Mx-ReqToken',
        'Keep-Alive',
        'X-Requested-With',
        'If-Modified-Since',
        'X-CSRF-TOKEN'
    ],
    exposedHeaders: [
        'Content-Disposition',
        'Content-Type',
        'Cache-Control'
    ],
    maxAge: 3600,
    preflightContinue: false,
    optionsSuccessStatus: 204
}));

// 错误处理中间件
app.use((err, req, res, next) => {
    if (err.message === 'CORS policy violation') {
        return res.status(403).json({
            error: 'CORS Error',
            message: 'This origin is not allowed to access the resource'
        });
    }
    next(err);
});

// 解析 JSON 请求体
app.use(express.json({
    limit: '10mb',  // 限制请求体大小
    strict: true,   // 严格模式
    type: 'application/json'
}));

app.use(express.urlencoded({ extended: true }));

// API Keys
const XAI_API_KEY = process.env.XAI_API_KEY;  //XAI_API_KEY
// const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
// const GMINI_API_KEY = process.env.GMINI_API_KEY;
const CLAUDE_API_KEY = process.env.CLAUDE_API_KEY;
const API_SECRET = process.env.API_SECRET;
const SPARK_API_KEY = process.env.SPARK_API_KEY;  // 讯飞星火API Key
// const SPARK_API_SECRET = process.env.SPARK_API_SECRET;
// const SPARK_APP_ID = process.env.SPARK_APP_ID;

// Verify API secret middleware
const verifyApiSecret = (req, res, next) => {
    const apiSecret = req.headers['x-api-secret'];
    console.log('\n=== API 验证信息 ===');
    console.log(`期望的密钥: ${API_SECRET}`);
    console.log(`收到的密钥: ${apiSecret}`);

    if (!apiSecret || apiSecret !== API_SECRET) {
        console.log('验证失败！');
        return res.status(401).json({ message: 'Invalid server API secret' });
    }

    console.log('验证成功！');
    console.log('=== API 验证结束 ===\n');
    next();
};

// 静态文件服务
app.use(express.static(path.join(__dirname, '../client/dist')));

// X.AI Chat endpoint
app.post('/api/chat/xai', verifyApiSecret, async (req, res) => {
    try {
        console.log('\n=== X.AI API Request Start ===');
        console.log('Request Body:', JSON.stringify(req.body, null, 2));
        console.log('Environment:', {
            NODE_ENV: process.env.NODE_ENV,
            API_KEY_LENGTH: process.env.XAI_API_KEY ? process.env.XAI_API_KEY.length : 0,
            PROXY_CONFIG: {
                HTTP_PROXY: process.env.HTTP_PROXY,
                HTTPS_PROXY: process.env.HTTPS_PROXY
            }
        });

        if (!XAI_API_KEY) {
            throw new Error('XAI API key is missing');
        }

        if (!req.body.messages || req.body.messages.length === 0) {
            throw new Error('Messages cannot be empty');
        }

        // 构建请求配置
        const apiUrl = 'https://api.x.ai/v1/chat/completions';
        const requestConfig = {
            headers: {
                'Authorization': `Bearer ${XAI_API_KEY}`,
                'Content-Type': 'application/json'
            },
            // 添加代理配置
            proxy: false, // 使用全局代理设置
            timeout: 30000, // 30秒超时
            httpsAgent: proxyAgent // 使用配置的代理
        };

        const requestData = {
            messages: req.body.messages,
            model: req.body.model || 'gpt-3.5-turbo',
            temperature: req.body.temperature || 0,
            stream: req.body.stream || false
        };

        console.log('API URL:', apiUrl);
        console.log('Request Config:', JSON.stringify({
            ...requestConfig,
            headers: {
                ...requestConfig.headers,
                'Authorization': 'Bearer [HIDDEN]'
            }
        }, null, 2));
        console.log('Request Data:', JSON.stringify(requestData, null, 2));

        // 使用配置了代理的 axios 实例
        const response = await axiosInstance.post(apiUrl, requestData, requestConfig);
        console.log('Response Status:', response.status);
        console.log('Response Headers:', JSON.stringify(response.headers, null, 2));
        console.log('Response Data:', JSON.stringify(response.data, null, 2));
        console.log('=== X.AI API Request End ===\n');
        res.json(response.data);
    } catch (error) {
        console.error('\n=== X.AI API Error ===');
        console.error('Error Type:', error.constructor.name);
        console.error('Error Message:', error.message);

        if (error.response) {
            console.error('Error Response Status:', error.response.status);
            console.error('Error Response Headers:', JSON.stringify(error.response.headers, null, 2));
            console.error('Error Response Data:', error.response.data);

            res.status(error.response.status).json({
                status: 'error',
                error: error.message,
                details: error.response.data
            });
        } else {
            // 网络错误或其他错误
            console.error('Network or Other Error:', error);
            res.status(502).json({
                status: 'error',
                error: '网络错误或服务不可用',
                details: error.message
            });
        }
    }
});

// OpenAI Chat endpoint
app.post('/api/chat/openai', verifyApiSecret, async (req, res) => {
    try {
        console.log('\n=== OpenAI API 请求详情 START ==================');
        console.log('请求路径:', req.path);
        console.log('请求方法:', req.method);
        // console.log('请求头:', JSON.stringify(req.headers, null, 2));
        console.log('请求体:', JSON.stringify(req.body, null, 2));

        // 参数验证
        if (!req.body || !req.body.messages) {
            return res.status(400).json({
                error: '请求参数错误',
                message: '缺少必要的消息参数'
            });
        }

        const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
        if (!OPENAI_API_KEY) {
            return res.status(500).json({ error: 'OpenAI API Key 未配置' });
        }

        // 获取系统代理配置
        const HTTP_PROXY = process.env.HTTP_PROXY;
        const HTTPS_PROXY = process.env.HTTPS_PROXY;

        // 使用官方 OpenAI SDK，配置代理和网络选项
        const openai = new OpenAI({
            apiKey: OPENAI_API_KEY,
            // 配置代理和网络超时
            httpAgent: HTTP_PROXY ? new HttpsProxyAgent(HTTP_PROXY) : undefined,
            httpsAgent: HTTPS_PROXY ? new HttpsProxyAgent(HTTPS_PROXY) : undefined,
            // 网络配置
            timeout: 30000,  // 30秒超时
            maxRetries: 2,   // 最多重试2次
            // 禁用 SSL 验证（仅在调试时使用）
            fetch: (url, options = {}) => {
                return fetch(url, {
                    ...options,
                    agent: HTTPS_PROXY ? new HttpsProxyAgent(HTTPS_PROXY) : undefined
                });
            }
        });

        const requestData = {
            model: req.body.model || 'gpt-3.5-turbo',
            messages: req.body.messages,
            temperature: req.body.temperature || 0,
            stream: req.body.stream || false
        };

        console.log('请求数据:', JSON.stringify(requestData, null, 2));
        console.log('使用代理:', HTTP_PROXY || HTTPS_PROXY || '无');

        const completion = await openai.chat.completions.create(requestData);

        console.log('OpenAI 响应详情:', JSON.stringify(completion, null, 2));
        // console.log('OpenAI 请求详情 END ==================');

        res.json(completion);
    } catch (error) {
        // console.error('OpenAI 请求错误 START ==================');
        console.error('错误类型:', error.constructor.name);
        // console.error('错误信息:', error.message);
        // console.error('错误堆栈:', error.stack);
        // console.log('错误状态码1:', error.status);
        // 详细打印错误响应
        if (error) {
            console.log('错误状态码2:', error.status);
            // console.error('错误响应数据:', JSON.stringify(error.response.data, null, 2));
            // console.error('错误响应头:', JSON.stringify(error.response.headers, null, 2));

            // 如果是 429 状态码（额度不足），返回特定的错误信息
            if (error.status === 429) {
                console.error('额度不足错误');
                return res.status(429).json({
                    error: '额度不足',
                    message: 'OpenAI API 额度已用完，请检查账户余额和计费状态',
                    details: error.data || { error }
                });
            }
        }

        // console.error('OpenAI 请求错误 END ==================');

        // 根据错误类型返回适当的响应
        if (error instanceof OpenAI.APIConnectionError) {
            return res.status(500).json({
                error: '网络连接错误',
                message: '无法连接到 OpenAI 服务器',
                details: error.message
            });
        }

        // 其他未知错误
        res.status(500).json({
            error: '服务器内部错误',
            message: error.message
        });
    }
});

// Gemini Chat endpoint
app.post('/api/chat/gmini', verifyApiSecret, async (req, res) => {
    try {
        console.log('\n=== Gemini API 请求开始 ===');
        console.log('请求体:', JSON.stringify(req.body, null, 2));

        const { messages } = req.body;

        if (!messages || messages.length === 0) {
            return res.status(400).json({ error: '消息不能为空' });
        }

        // 使用环境变量中的 API Key
        const genAI = new GoogleGenerativeAI(process.env.GMINI_API_KEY);

        // 使用 gemini-pro 模型
        const model = genAI.getGenerativeModel({ model: "gemini-pro" });

        // 准备消息历史
        const chatHistory = messages.map(msg => ({
            role: msg.role,
            parts: [{ text: msg.content }]
        }));

        // 获取最后一条消息
        const lastMessage = messages[messages.length - 1].content;

        try {
            const result = await model.generateContent(lastMessage);
            const response = result.response;

            console.log('Gemini API 响应:', response.text());

            res.json({
                choices: [{
                    message: {
                        role: 'assistant',
                        content: response.text()
                    }
                }]
            });
        } catch (generateError) {
            console.error('Gemini API 生成内容错误:', generateError);
            res.status(500).json({
                error: '生成内容时发生错误或API不支持本地区使用',
                details: generateError.message
            });
        }
    } catch (error) {
        console.error('Gemini API 请求错误:', error);
        res.status(500).json({
            error: 'Gemini API 请求失败',
            details: error.message
        });
    }
});


// 讯飞星火SparkPro Chat endpoint
app.post('/api/chat/spark', verifyApiSecret, async (req, res) => {
    try {
        console.log('\n=== SparkPro API 请求开始 ===');
        console.log('前端请求路径:', req.path);
        console.log('前端请求方法:', req.method);

        // 参数验证
        if (!req.body || !req.body.messages) {
            return res.status(400).json({
                error: '请求参数错误',
                message: '缺少必要的消息参数'
            });
        }

        // 检查API密钥
        if (!SPARK_API_KEY) {
            console.log('API密钥验证失败：讯飞星火 API Key 未配置');
            return res.status(500).json({
                error: 'API配置错误',
                message: '讯飞星火 API Key 未配置'
            });
        }

        const url = "https://spark-api-open.xf-yun.com/v1/chat/completions";

        console.log('\n=== 请求详情 ===');
        console.log('完整URL:', url);

        // 检查代理设置
        console.log('\n=== 代理设置 ===');
        console.log('HTTP_PROXY:', process.env.HTTP_PROXY);
        console.log('HTTPS_PROXY:', process.env.HTTPS_PROXY);

        console.log('\n开始发送请求...');
        // 创建一个不使用代理的 axios 实例专门用于讯飞星火API
        const sparkAxios = axios.create({
            timeout: 60000,
            proxy: false, // 禁用代理
            httpsAgent: new https.Agent({
                rejectUnauthorized: true,
                keepAlive: true
            })
        });

        const response = await sparkAxios({
            method: 'post',
            url: url,
            headers: {
                'Authorization': 'Bearer  ' + SPARK_API_KEY,
                'User-Agent': 'Apifox/1.0.0 (https://apifox.com)',
                'Content-Type': 'application/json',
                'Accept': '*/*',
                'Host': 'spark-api-open.xf-yun.com',
                'Connection': 'keep-alive'
            },
            data: JSON.stringify({
                model: req.body.model || "generalv3.5",
                messages: req.body.messages
            }),
            validateStatus: function (status) {
                console.log('响应状态码:', status);
                return true;
            },
            timeout: 60000,
            proxy: false  // 再次确保不使用代理
        });
        console.log('请求已发送，等待响应...');

        // 根据状态码处理响应
        if (response.status === 404) {
            console.log('API返回404错误:');
            console.log('响应数据:', response.data);
            console.log('响应头:', response.headers);
            console.log('=== SparkPro API 请求结束 ===\n');
            return res.status(404).json({
                error: '请求失败: ' + (response.data || '未知错误'),
                status: response.status,
                path: url
            });
        } else if (response.status === 200) {
            console.log('API请求成功');
            // console.log('讯飞星火API响应成功', response.headers);
            console.log('响应状态码:', response.status);
            // console.log('响应头:', JSON.stringify(response.headers, null, 2));
            // console.log('SparkPro API响应:', JSON.stringify(response.data, null, 2));
            console.log('=== SparkPro API 请求结束 ===\n');
            return res.json(response.data);
        } else {
            console.log(`API返回状态码 ${response.status}:`, response.data);
            console.log('=== SparkPro API 请求结束 ===\n');
            return res.status(response.status).json({
                error: '请求失败: ' + (response.data || '未知错误'),
                status: response.status,
                path: url
            });
        }
    } catch (error) {
        console.error('\n=== SparkPro API 错误 ===');
        console.error('错误类型:', error.constructor.name);
        console.error('错误信息:', error.message);
        console.error('错误堆栈:', error.stack);

        if (error.response) {
            console.error('错误响应状态码:', error.response.status);
            console.error('错误响应头:', JSON.stringify(error.response.headers, null, 2));
            console.error('错误响应数据:', JSON.stringify(error.response.data, null, 2));
        }

        // 解析详细错误信息
        let errorDetails = error.toString();
        let statusCode = 500;
        let errorMessage = '讯飞星火 API 请求失败';

        if (error.response) {
            try {
                errorDetails = error.response.data;
                statusCode = error.response.status;

                // 处理HTTP状态码错误
                switch (error.response.status) {
                    case 401:
                        errorMessage = '后端API认证失败,请检查API Key(不是讯飞星火的API Key)';
                        break;
                    case 429:
                        errorMessage = 'API调用频率超限';
                        break;
                    case 400:
                        errorMessage = '请求参数错误';
                        break;
                    case 404:
                        errorMessage = '请求的资源未找到';
                        break;
                }
                // throw new Error(errorMessage);
                // 处理讯飞星火API的业务错误码
                if (error.response.data && error.response.data.code) {
                    const code = error.response.data.code;
                    switch (code) {
                        case 10007:
                            statusCode = 429;
                            errorMessage = '请等待上一个问题处理完成后再发送新的请求';
                            break;
                        case 10013:
                            statusCode = 400;
                            errorMessage = '输入内容审核不通过，请调整输入内容';
                            break;
                        case 10014:
                            statusCode = 400;
                            errorMessage = '输出内容涉及敏感信息，无法显示';
                            break;
                        case 10019:
                            statusCode = 400;
                            errorMessage = '输入内容可能涉及违规信息，请调整';
                            break;
                        case 10907:
                            statusCode = 400;
                            errorMessage = '对话历史与问题字数超过上限，请精简输入';
                            break;
                        case 11200:
                            statusCode = 403;
                            errorMessage = '该账号没有相关功能的授权或业务量超过限制';
                            break;
                        case 11201:
                            statusCode = 429;
                            errorMessage = '已超过当日最大访问量限制';
                            break;
                        case 11202:
                            statusCode = 429;
                            errorMessage = '秒级访问超过限制';
                            break;
                        case 11203:
                            statusCode = 429;
                            errorMessage = '并发访问超过限制';
                            break;

                    }

                }

                throw new Error(errorMessage);
            } catch (e) {
                console.error('解析错误响应时出错:', e);
                errorDetails = error.response.toString();
            }
        }

        console.error('最终错误信息:', {
            statusCode,
            errorMessage,
            errorDetails
        });

        // 返回标准化的错误响应
        res.status(statusCode).json({
            error: errorMessage,
            message: error.message,
            details: errorDetails,
            code: error.response?.data?.code,
            type: error.type || 'unknown'
        });

        console.error('=== SparkPro API 错误处理结束 ===\n');
        throw new Error(errorMessage);

    }
});

// 百度文心一言API路由  提供前端获取单次token  未有做前端token验证
app.post('/api/baidu/token', async (req, res) => {
    try {
        const { client_id, client_secret } = req.body;
        if (!client_id || !client_secret) {
            return res.status(400).json({
                error: 'Missing client_id or client_secret'
            });
        }

        const tokenData = await ernieService.getAccessToken(client_id, client_secret);
        res.json(tokenData);
    } catch (error) {
        console.error('Baidu token error:', error);
        res.status(500).json({
            error: error.response?.data?.error_description || error.message
        });
    }
});

// 百度文心一言API路由 聊天服务接口  未有做前端token验证
app.post('/api/baidu/chat', async (req, res) => {
    try {
        const { access_token, messages, ...params } = req.body;
        if (!access_token || !messages) {
            return res.status(400).json({
                error: 'Missing access_token or messages'
            });
        }

        const response = await ernieService.chat(access_token, messages, params);
        res.json(response);
    } catch (error) {
        console.error('Baidu chat error:', error);
        res.status(500).json({
            error: error.response?.data?.error_msg || error.message
        });
    }
});

// 通义千问API路由  未有做前端token验证
app.post('/api/chat/qwen', async (req, res) => {
    try {
        console.log('=== 通义千问请求参数 ===');
        console.log('请求体:', JSON.stringify(req.body, null, 2));
        console.log('环境变量:', {
            VITE_APP_QWEN_API_KEY: process.env.VITE_APP_QWEN_API_KEY ? '已设置' : '未设置'
        });

        if (!req.body.messages || !Array.isArray(req.body.messages)) {
            throw new Error('无效的消息格式：messages 必须是数组');
        }

        try {
            const result = await qwenService.chat({
                model: req.body.model,
                messages: req.body.messages
            });
            
            console.log('=== 通义千问响应结果 ===');
            console.log('响应:', JSON.stringify(result, null, 2));
            
            res.json(result);
        } catch (serviceError) {
            console.error('=== 通义千问服务错误 ===');
            console.error('错误类型:', serviceError.constructor.name);
            console.error('错误信息:', serviceError.message);
            console.error('错误详情:', serviceError.error || serviceError);
            
            // 重新抛出错误，让外层错误处理来处理
            throw serviceError;
        }
    } catch (error) {
        console.error('=== 通义千问API错误 ===');
        console.error('错误类型:', error.constructor.name);
        console.error('错误信息:', error.message);
        console.error('错误详情:', error.error || error);
        console.error('错误堆栈:', error.stack);
        
        // 返回更详细的错误信息
        res.status(500).json({
            success: false,
            message: error.message || '请求失败',
            error: error.error || error.message,
            type: error.constructor.name
        });
    }
});


// Claude API 测试接口
app.get('/api/test/claude', async (req, res) => {
    try {
        console.log('\n=== Claude API 测试 ===');

        // 检查API密钥
        if (!CLAUDE_API_KEY) {
            throw new Error('Claude API密钥未设置');
        }
        console.log('API Key:', '已设置');

        // 获取代理设置
        const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
        console.log('代理设置:', proxyUrl || '未使用代理');

        // 初始化 Anthropic 客户端配置
        const anthropicConfig = {
            apiKey: CLAUDE_API_KEY,
        };

        // 如果有代理，添加代理配置
        if (proxyUrl) {
            const proxyAgent = new HttpsProxyAgent(proxyUrl);
            anthropicConfig.httpAgent = proxyAgent;
            anthropicConfig.httpsAgent = proxyAgent;
            console.log('已配置代理');
        }

        // 初始化 Anthropic 客户端
        const anthropic = new Anthropic(anthropicConfig);
        console.log('已初始化 Claude API');

        // 测试消息
        const testMessage = {
            model: "claude-3-haiku-20240307",
            max_tokens: 1000,
            messages: [
                {
                    role: "user",
                    content: "你好，这是一条测试消息。请用中文回复。"
                }
            ]
        };

        console.log('发送测试消息...');
        const response = await anthropic.messages.create(testMessage);

        console.log('测试响应:', response);
        res.json({
            status: 'success',
            response: response
        });

    } catch (error) {
        console.error('\n=== Claude API 测试错误 ===');
        console.error('错误类型:', error.constructor.name);
        console.error('错误信息:', error.message);

        // 解析详细错误信息
        let errorDetails = error.toString();
        if (error.response) {
            try {
                errorDetails = JSON.stringify(error.response.data || error.response, null, 2);
            } catch (e) {
                errorDetails = error.response.toString();
            }
        }

        res.status(500).json({
            status: 'error',
            error: `Claude API 测试错误: ${error.message}`,
            details: errorDetails,
            type: error.type || 'unknown'
        });
    }
});

// DeepSeek 接口
app.post('/api/deepseek', async (req, res) => {
    try {
        const { messages } = req.body;

        // 验证 messages 是否为数组
        if (!Array.isArray(messages)) {
            console.error('Invalid messages format. It should be an array.');
            return res.status(400).json({ error: 'Invalid messages format. It should be an array.' });
        } else {
            console.log('=== DeepSeek 请求参数 ===', messages);
        }

        const openai = new OpenAI({
            baseURL: 'https://api.deepseek.com',
            apiKey: process.env.DEEPSEEK_API_KEY
        });

        // 创建一个openai聊天补全对象
        const completion = await openai.chat.completions.create({
            // 设置消息内容，包括系统角色和用户消息
            messages: [{ role: "system", content: "You are a helpful assistant." }, ...messages],
            // 设置模型为deepseek-chat
            model: "deepseek-chat",
        });

        res.json(completion.choices[0].message);
    } catch (error) {
        console.error('Error:', error);

        // 处理 402 Insufficient Balance 错误
        if (error.status === 402) {
            return res.status(402).json({
                error: 'Insufficient Balance',
                message: 'Your account balance is insufficient to process this request.'
            });
        }

        res.status(500).json({ error: 'Failed to fetch response from DeepSeek API' });
    }
});

// Health check endpoint
app.get('/api/health', (req, res) => {
    console.log('=== 健康检查 请求：===', req);
    res.json({ status: 'healthy' });
});

// 处理所有非 API 路由
app.get(/^(?!\/api).*/, (req, res) => {
    res.sendFile(path.join(__dirname, '../client/dist/index.html'));
});

// Start server
const port = process.env.VITE_APP_API_PORT || 8000;
const host = process.env.VITE_APP_API_HOST || 'localhost';

app.listen(port, host, () => {
    console.log(`Server running at http://${host}:${port}/`);
    console.log('Environment:', process.env.NODE_ENV || 'development');
    console.log('Allowed Origins:', ['http://localhost:8000', 'http://localhost']);
    console.log(`API Base URL: ${process.env.VITE_APP_API_BASE_URL}`);
});

// 处理所有非 API 路由
app.get('*',(req,res) => {
  res.sendFile(path.join(__dirname,'../client/dist/index.html'));
});